{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dimensionality reduction with t-SNE\n",
    "\n",
    "t-Distributed Stochastic Neighbor Embedding (t-SNE) is a technique for dimensionality reduction that is particularly well suited for the [visualization of high-dimensional datasets](https://lvdmaaten.github.io/tsne/). It was created by [van der Maaten and Hinton](https://lvdmaaten.github.io/publications/papers/JMLR_2008.pdf) in 2008. \n",
    "\n",
    "In this notebooks, we are going to show how t-SNE works using features extracted from the kaggle dataset [dogs vs cats](https://www.kaggle.com/c/dogs-vs-cats/). For extracting the features, we will use ResNet50 as featurizer. \n",
    "\n",
    "We present and compare two implementations of t-SNE: [sklearn](http://scikit-learn.org/stable/modules/generated/sklearn.manifold.TSNE.html), implemented in python and [CUDA](https://github.com/georgedimitriadis/t_sne_bhcuda), implemented by George Dimitriadis in CUDA/C++ with python wrappers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "System version: 3.5.5 |Anaconda custom (64-bit)| (default, May 13 2018, 21:12:35) \n",
      "[GCC 7.2.0]\n",
      "Sklearn version: 0.19.1\n",
      "Numpy version: 1.14.5\n",
      "Kaggle version: 1.5.0\n",
      "Keras version: 2.2.2\n",
      "Keras backend: tensorflow\n",
      "Keras image data format: channels_last\n",
      "Tensorflow version: 1.10.1\n",
      "GPU: ['Tesla K80']\n",
      "CUDA version: CUDA Version 9.2.148\n",
      "CuDNN version: 7.2.1\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import keras as K\n",
    "from keras.applications.nasnet import NASNetLarge\n",
    "from keras.applications.resnet50 import ResNet50\n",
    "import tensorflow as tf\n",
    "import kaggle\n",
    "from numba import cuda\n",
    "import t_sne_bhcuda.t_sne_bhcuda.bhtsne_cuda as tsne_bhcuda\n",
    "from utils import (plot_tsne, get_gpu_name, get_cuda_version, get_cudnn_version,\n",
    "                   find_files_with_pattern, featurize_images, clear_memory_all_gpus)\n",
    "\n",
    "print(\"System version: {}\".format(sys.version))\n",
    "print(\"Sklearn version: {}\".format(sklearn.__version__))\n",
    "print(\"Numpy version: {}\".format(np.__version__))\n",
    "print(\"Kaggle version: {}\".format(kaggle.KaggleApi.__version__))\n",
    "print(\"Keras version: {}\".format(K.__version__))\n",
    "print(\"Keras backend: {}\".format(K.backend.backend()))\n",
    "print(\"Keras image data format: {}\".format(K.backend.image_data_format()))\n",
    "print(\"Tensorflow version: {}\".format(tf.__version__))\n",
    "print(\"GPU: {}\".format(get_gpu_name()))\n",
    "print(\"CUDA version: {}\".format(get_cuda_version()))\n",
    "print(\"CuDNN version: {}\".format(get_cudnn_version()))\n",
    "\n",
    "\n",
    "# Autoreload changes in imported files\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "# Allow multiple displays per cell\n",
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = \"all\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dataset\n",
    "\n",
    "For testing the algorithm we are going to use the [Dogs vs Cats](https://www.kaggle.com/c/dogs-vs-cats/data) dataset, which contains 2 classes and 25000 images.\n",
    "\n",
    "Kaggle has a nice [api](https://github.com/Kaggle/kaggle-api) that allows one to programmatically work with their content. We can use their client to download the dataset. Make sure you follow the [instructions](https://github.com/Kaggle/kaggle-api#api-credentials) to get the Kaggle credentials. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading sampleSubmission.csv to /data/home/hoaphumanoid/notebooks/repos/sciblog_support/Dimensionality_Reduction_with_TSNE\n",
      "  0%|                                               | 0.00/86.8k [00:00<?, ?B/s]\n",
      "100%|██████████████████████████████████████| 86.8k/86.8k [00:00<00:00, 1.11MB/s]\n",
      "Downloading test1.zip to /data/home/hoaphumanoid/notebooks/repos/sciblog_support/Dimensionality_Reduction_with_TSNE\n",
      " 95%|█████████████████████████████████████▉  | 257M/271M [00:04<00:00, 34.0MB/s]\n",
      "100%|████████████████████████████████████████| 271M/271M [00:05<00:00, 54.4MB/s]\n",
      "Downloading train.zip to /data/home/hoaphumanoid/notebooks/repos/sciblog_support/Dimensionality_Reduction_with_TSNE\n",
      " 98%|███████████████████████████████████████▍| 535M/543M [00:07<00:00, 70.3MB/s]\n",
      "100%|████████████████████████████████████████| 543M/543M [00:12<00:00, 45.9MB/s]\n"
     ]
    }
   ],
   "source": [
    "!/anaconda/envs/py35/bin/kaggle competitions download -c dogs-vs-cats --force"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "!unzip -q train.zip"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a look at the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12500"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['train/dog.7647.jpg', 'train/dog.4124.jpg', 'train/dog.11342.jpg', 'train/dog.7021.jpg', 'train/dog.7305.jpg', 'train/dog.1757.jpg', 'train/dog.1804.jpg', 'train/dog.8312.jpg', 'train/dog.2823.jpg', 'train/dog.1423.jpg']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "12500"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['train/cat.6586.jpg', 'train/cat.11278.jpg', 'train/cat.8459.jpg', 'train/cat.1983.jpg', 'train/cat.5735.jpg', 'train/cat.3765.jpg', 'train/cat.10067.jpg', 'train/cat.6049.jpg', 'train/cat.783.jpg', 'train/cat.8995.jpg']\n"
     ]
    }
   ],
   "source": [
    "files_dog = find_files_with_pattern(\"train\", \"dog*\")\n",
    "len(files_dog)\n",
    "print(files_dog[:10])\n",
    "\n",
    "files_cat = find_files_with_pattern(\"train\", \"cat*\")\n",
    "len(files_cat)\n",
    "print(files_cat[:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we are going to subsample part of the data, we don't need all the data for our experiments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample = 5000\n",
    "files_dog = files_dog[:sample]\n",
    "files_cat = files_cat[:sample]\n",
    "file_names = files_dog + files_cat\n",
    "len(file_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "labels_dog = [0]*len(files_dog)\n",
    "labels_cat = [1]*len(files_cat)\n",
    "labels = labels_dog + labels_cat\n",
    "len(labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Image featurization\n",
    "\n",
    "CNNs are great featurizers, many times used in [transfer learning](https://miguelgfierro.com/blog/2017/a-gentle-introduction-to-transfer-learning-for-image-classification/). \n",
    "\n",
    "![ResNet CNN](https://cdn.rawgit.com/miguelgfierro/sciblog_support/master/A_Gentle_Introduction_to_Transfer_Learning/img/resnet.svg)\n",
    "\n",
    "The standard strategy is to remove the last layer of the CNN to featurize the input images. In our example, we will use [ResNet](https://arxiv.org/abs/1512.03385), pretrained on [ImageNet dataset](http://image-net.org/), with 50 layers. For this case, the input image is a matrix of `224x224x3` (height, weigth, color channels), and the output is a vector of 2048 floats, corresponding to the number of units of the penultimate layer. This vector is a very good low level representation of the original image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#https://keras.io/applications/#resnet50\n",
    "model = ResNet50(input_shape=(224, 224, 3), weights='imagenet', include_top=False, pooling='avg')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "157it [01:50,  1.54it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(10000, 2048)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "features = featurize_images(file_names, model)\n",
    "features.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# clear gpu memory\n",
    "del model\n",
    "clear_memory_all_gpus()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dimensionality reduction with t-SNE\n",
    "\n",
    "t-Distributed Stochastic Neighbor Embedding ([t-SNE](https://lvdmaaten.github.io/publications/papers/JMLR_2008.pdf)) algorithm, and its [faster implementation](https://lvdmaaten.github.io/publications/papers/JMLR_2014.pdf) are designed for visualization of high-dimensional data in scatter plots. t-SNE is an improvement over [SNE](http://papers.nips.cc/paper/2276-stochastic-neighbor-embedding.pdf) developed years later by Hinton et al. \n",
    "\n",
    "t-SNE reduces the dimensionality of a high-dimensional dataset $X={x_1, x_2, ..., x_n}$ to a two or three dimensional dataset $Y={y_1, y_2, ..., y_n}$, by modeling the high-dimensional Euclidean distances between datapoints as joint probabilities $p_{ij}$ that represent similarities. For nearby data points, $p_{ij}$ is relatively high, and for separated points, $p_{ij}$ is low. The joint probability is computed based on the conditional probability $p_{j/i}$, which is as a Gaussian centered in $x_i$, and defined as $p_{ij} = (p_{j/i} + p_{i/j})/2n$, where \n",
    "\n",
    "$$ p_{j/i} = \\frac{exp( - \\lVert x_i - x_j \\rVert^2/2\\sigma_i^2)}{\\sum_{k\\ne i} exp( - \\lVert x_i - x_k \\rVert^2/2\\sigma_i^2) )}$$\n",
    "\n",
    "\n",
    "For the low-dimensional space, the authors use [Student t-distribution](https://en.wikipedia.org/wiki/Student%27s_t-distribution) with one degree of freedom to convert pairwise distances into probabilities. \n",
    "\n",
    "$$ q_{ij} = \\frac{ ( 1 + \\lVert y_i - y_j \\rVert^2 )^{-1} }{\\sum_{k\\ne l} ( 1 + \\lVert y_i - y_j \\rVert^2 )^{-1} )}$$\n",
    "\n",
    "Here, the $y$ in the $q_{ij}$ are the learned parameters, i.e. the low dimensional space. Student t-distribution has a several nice properties that makes it preferable over the Gaussian. \n",
    "\n",
    "First, it addresses the *crowded problem*, which is explained by the authors as \"in ten dimensions, it is possible to have 11 datapoints that are mutually equidistant and there is no way to model this faithfully in a two-dimensional map\". Student t-distribution is a heavy-tailed distribution, and therefore it is almost invariant to changes in the scale of points that are far apart. This effectively means that when mapping pairwise distances from the high-dimensional space to the low-dimensional space, the scale between points is roughly maintained. \n",
    "\n",
    "Second, the t-distribution is computationally faster to evaluate in comparison with the Gaussian, since it doesn't involve an exponential. \n",
    "\n",
    "The final step in the algorithm is to minimize the mismatch between $p_{ij}$ and $q_{ij}$. For that task, the authors use the [Kullback-Liebler divergence](https://en.wikipedia.org/wiki/Kullback%E2%80%93Leibler_divergence):\n",
    "\n",
    "$$ \\min KL(P\\lVert Q) = \\min \\sum_i \\sum_j p_{ij}\\log\\frac{p_{ij}}{q_{ij}} $$\n",
    "\n",
    "To optimize this cost function, a gradient descent method can be used. The gradient is:\n",
    "\n",
    "$$ \\frac{\\delta C}{\\delta y_i} = 4 \\sum_j (p_{ij} - q_{ij})(y_i - y_j)( 1 + \\lVert y_i - y_j \\rVert^2 )^{-1} $$\n",
    "\n",
    "Under some circustances, t-SNE can generate clusters, as some authors have proved [here](https://arxiv.org/abs/1706.02582) and [here](https://arxiv.org/abs/1803.01768). However, this is [not always the case](https://stats.stackexchange.com/questions/263539/clustering-on-the-output-of-t-sne/264647#264647), and such clusters can appear in non-clustered data.\n",
    "\n",
    "### t-SNE implementation\n",
    "\n",
    "Next, we compute t-SNE with the features obtained from the CNN, using two implementations: [sklearn](http://scikit-learn.org/stable/modules/generated/sklearn.manifold.TSNE.html), and [CUDA](https://github.com/georgedimitriadis/t_sne_bhcuda).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "perplexity = 10.0\n",
    "theta = 0.5\n",
    "learning_rate = 200.0\n",
    "iterations = 2000\n",
    "gpu_mem = 0.95\n",
    "files_dir='tsne_results'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[t-SNE] Computing 31 nearest neighbors...\n",
      "[t-SNE] Indexed 10000 samples in 1.374s...\n",
      "[t-SNE] Computed neighbors for 10000 samples in 386.236s...\n",
      "[t-SNE] Computed conditional probabilities for sample 1000 / 10000\n",
      "[t-SNE] Computed conditional probabilities for sample 2000 / 10000\n",
      "[t-SNE] Computed conditional probabilities for sample 3000 / 10000\n",
      "[t-SNE] Computed conditional probabilities for sample 4000 / 10000\n",
      "[t-SNE] Computed conditional probabilities for sample 5000 / 10000\n",
      "[t-SNE] Computed conditional probabilities for sample 6000 / 10000\n",
      "[t-SNE] Computed conditional probabilities for sample 7000 / 10000\n",
      "[t-SNE] Computed conditional probabilities for sample 8000 / 10000\n",
      "[t-SNE] Computed conditional probabilities for sample 9000 / 10000\n",
      "[t-SNE] Computed conditional probabilities for sample 10000 / 10000\n",
      "[t-SNE] Mean sigma: 5.098726\n",
      "[t-SNE] Computed conditional probabilities in 0.780s\n",
      "[t-SNE] Iteration 50: error = 28.9407291, gradient norm = 0.0125538 (50 iterations in 12.188s)\n",
      "[t-SNE] Iteration 100: error = 26.1812706, gradient norm = 0.0010976 (50 iterations in 8.159s)\n",
      "[t-SNE] Iteration 150: error = 25.9291000, gradient norm = 0.0004139 (50 iterations in 7.987s)\n",
      "[t-SNE] Iteration 200: error = 25.8412113, gradient norm = 0.0002460 (50 iterations in 8.301s)\n",
      "[t-SNE] Iteration 250: error = 25.7991257, gradient norm = 0.0001792 (50 iterations in 8.424s)\n",
      "[t-SNE] KL divergence after 250 iterations with early exaggeration: 25.799126\n",
      "[t-SNE] Iteration 300: error = 4.1348209, gradient norm = 0.0010998 (50 iterations in 8.078s)\n",
      "[t-SNE] Iteration 350: error = 3.7202637, gradient norm = 0.0005517 (50 iterations in 8.012s)\n",
      "[t-SNE] Iteration 400: error = 3.4989183, gradient norm = 0.0003529 (50 iterations in 7.935s)\n",
      "[t-SNE] Iteration 450: error = 3.3583200, gradient norm = 0.0002550 (50 iterations in 7.886s)\n",
      "[t-SNE] Iteration 500: error = 3.2601931, gradient norm = 0.0002021 (50 iterations in 7.851s)\n",
      "[t-SNE] Iteration 550: error = 3.1889222, gradient norm = 0.0001667 (50 iterations in 7.823s)\n",
      "[t-SNE] Iteration 600: error = 3.1343441, gradient norm = 0.0001414 (50 iterations in 7.877s)\n",
      "[t-SNE] Iteration 650: error = 3.0911403, gradient norm = 0.0001242 (50 iterations in 7.956s)\n",
      "[t-SNE] Iteration 700: error = 3.0565217, gradient norm = 0.0001088 (50 iterations in 7.966s)\n",
      "[t-SNE] Iteration 750: error = 3.0284603, gradient norm = 0.0000971 (50 iterations in 8.062s)\n",
      "[t-SNE] Iteration 800: error = 3.0050213, gradient norm = 0.0000919 (50 iterations in 8.081s)\n",
      "[t-SNE] Iteration 850: error = 2.9855082, gradient norm = 0.0000819 (50 iterations in 8.048s)\n",
      "[t-SNE] Iteration 900: error = 2.9690773, gradient norm = 0.0000749 (50 iterations in 8.102s)\n",
      "[t-SNE] Iteration 950: error = 2.9550335, gradient norm = 0.0000695 (50 iterations in 8.145s)\n",
      "[t-SNE] Iteration 1000: error = 2.9431021, gradient norm = 0.0000655 (50 iterations in 8.146s)\n",
      "[t-SNE] Iteration 1050: error = 2.9327931, gradient norm = 0.0000628 (50 iterations in 8.163s)\n",
      "[t-SNE] Iteration 1100: error = 2.9239330, gradient norm = 0.0000593 (50 iterations in 8.174s)\n",
      "[t-SNE] Iteration 1150: error = 2.9163561, gradient norm = 0.0000572 (50 iterations in 8.098s)\n",
      "[t-SNE] Iteration 1200: error = 2.9099030, gradient norm = 0.0000548 (50 iterations in 8.274s)\n",
      "[t-SNE] Iteration 1250: error = 2.9041936, gradient norm = 0.0000533 (50 iterations in 8.255s)\n",
      "[t-SNE] Iteration 1300: error = 2.8990877, gradient norm = 0.0000528 (50 iterations in 8.144s)\n",
      "[t-SNE] Iteration 1350: error = 2.8947442, gradient norm = 0.0000509 (50 iterations in 8.200s)\n",
      "[t-SNE] Iteration 1400: error = 2.8908005, gradient norm = 0.0000503 (50 iterations in 8.144s)\n",
      "[t-SNE] Iteration 1450: error = 2.8872786, gradient norm = 0.0000485 (50 iterations in 8.211s)\n",
      "[t-SNE] Iteration 1500: error = 2.8840554, gradient norm = 0.0000480 (50 iterations in 8.249s)\n",
      "[t-SNE] Iteration 1550: error = 2.8811605, gradient norm = 0.0000474 (50 iterations in 8.218s)\n",
      "[t-SNE] Iteration 1600: error = 2.8784990, gradient norm = 0.0000464 (50 iterations in 8.237s)\n",
      "[t-SNE] Iteration 1650: error = 2.8759775, gradient norm = 0.0000460 (50 iterations in 8.263s)\n",
      "[t-SNE] Iteration 1700: error = 2.8738217, gradient norm = 0.0000456 (50 iterations in 8.211s)\n",
      "[t-SNE] Iteration 1750: error = 2.8717222, gradient norm = 0.0000452 (50 iterations in 8.224s)\n",
      "[t-SNE] Iteration 1800: error = 2.8698525, gradient norm = 0.0000444 (50 iterations in 8.270s)\n",
      "[t-SNE] Iteration 1850: error = 2.8681488, gradient norm = 0.0000435 (50 iterations in 8.209s)\n",
      "[t-SNE] Iteration 1900: error = 2.8664656, gradient norm = 0.0000425 (50 iterations in 8.232s)\n",
      "[t-SNE] Iteration 1950: error = 2.8649714, gradient norm = 0.0000438 (50 iterations in 8.249s)\n",
      "[t-SNE] Iteration 2000: error = 2.8635528, gradient norm = 0.0000443 (50 iterations in 8.303s)\n",
      "[t-SNE] Error after 2000 iterations: 2.863553\n",
      "CPU times: user 21min 10s, sys: 1min 40s, total: 22min 51s\n",
      "Wall time: 11min 57s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "t_sne_result_sklearn = tsne_bhcuda.t_sne(samples=features, use_scikit=True, files_dir=files_dir,\n",
    "                        no_dims=2, perplexity=perplexity, eta=learning_rate, theta=theta,\n",
    "                        iterations=iterations, gpu_mem=gpu_mem, randseed=77, verbose=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_tsne(t_sne_result_sklearn, labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Read the 10000 x 2048 data matrix successfully!\n",
      "Using random seed: 77\n",
      "Using no_dims = 2, perplexity = 10.000000, learning rate = 200.000000, and theta = 0.500000\n",
      "Computing input similarities...\n",
      "\n",
      "Device Name = Tesla K80\n",
      "multiProcessorCount: 13\n",
      "totalGlobalMem (in MB): 11441.187500\n",
      "totalGlobalMem (in GB): 11.173035\n",
      "sharedMemPerBlock (in bytes): 49152\n",
      "Maximum number of threads per block: 1024\n",
      "Maximum size of each dimension of a block: 1024 x 1024 x 64\n",
      "Maximum sizes of each dimension of a grid: 2147483647 x 65535 x 65535\n",
      "Compute capability of the device = 3.7\n",
      "canMapHostMemory: TRUE\n",
      "deviceOverlap: TRUE\n",
      "GPU memory usage: used = 71.000000 MB, free = 11370.187500 MB, total = 11441.187500 MB\n",
      "\n",
      "GPU iteration = 0, distance elements calculated = 100000000\n",
      "GPU memory usage: used = 608.750000 MB, free = 10832.437500 MB, total = 11441.187500 MB\n",
      "Time spent in calculating all distances in GPU: 6.535329\n",
      "Building tree...\n",
      " - Building tree and finding perplexities, point 0 of 10000\n",
      "Time spent building tree and finding perplexities: 11.958919\n",
      "Input similarities computed in 25.09 seconds (sparsity = 0.005342)\n",
      "\n",
      "Learning embedding...\n",
      "Iteration 50: error is 106.452614 (50 iterations in 9.99 seconds)\n",
      "Iteration 100: error is 106.449905 (50 iterations in 14.15 seconds)\n",
      "Iteration 150: error is 100.845783 (50 iterations in 21.09 seconds)\n",
      "Iteration 200: error is 100.013084 (50 iterations in 21.15 seconds)\n",
      "Iteration 250: error is 5.838480 (50 iterations in 22.35 seconds)\n",
      "Iteration 300: error is 4.496217 (50 iterations in 10.45 seconds)\n",
      "Iteration 350: error is 4.165552 (50 iterations in 8.26 seconds)\n",
      "Iteration 400: error is 3.977826 (50 iterations in 8.08 seconds)\n",
      "Iteration 450: error is 3.850579 (50 iterations in 8.25 seconds)\n",
      "Iteration 500: error is 3.753753 (50 iterations in 8.23 seconds)\n",
      "Iteration 550: error is 3.675886 (50 iterations in 8.16 seconds)\n",
      "Iteration 600: error is 3.610638 (50 iterations in 8.08 seconds)\n",
      "Iteration 650: error is 3.555692 (50 iterations in 8.24 seconds)\n",
      "Iteration 700: error is 3.507965 (50 iterations in 8.22 seconds)\n",
      "Iteration 750: error is 3.466222 (50 iterations in 8.23 seconds)\n",
      "Iteration 800: error is 3.428914 (50 iterations in 8.42 seconds)\n",
      "Iteration 850: error is 3.395390 (50 iterations in 8.43 seconds)\n",
      "Iteration 900: error is 3.364912 (50 iterations in 8.41 seconds)\n",
      "Iteration 950: error is 3.337286 (50 iterations in 8.53 seconds)\n",
      "Iteration 1000: error is 3.312267 (50 iterations in 8.44 seconds)\n",
      "Iteration 1050: error is 3.289551 (50 iterations in 8.46 seconds)\n",
      "Iteration 1100: error is 3.269644 (50 iterations in 8.70 seconds)\n",
      "Iteration 1150: error is 3.250870 (50 iterations in 8.72 seconds)\n",
      "Iteration 1200: error is 3.233367 (50 iterations in 8.68 seconds)\n",
      "Iteration 1250: error is 3.216774 (50 iterations in 9.07 seconds)\n",
      "Iteration 1300: error is 3.201303 (50 iterations in 8.89 seconds)\n",
      "Iteration 1350: error is 3.186859 (50 iterations in 8.94 seconds)\n",
      "Iteration 1400: error is 3.173519 (50 iterations in 8.96 seconds)\n",
      "Iteration 1450: error is 3.161005 (50 iterations in 8.94 seconds)\n",
      "Iteration 1500: error is 3.149215 (50 iterations in 9.11 seconds)\n",
      "Iteration 1550: error is 3.138102 (50 iterations in 9.02 seconds)\n",
      "Iteration 1600: error is 3.127803 (50 iterations in 9.14 seconds)\n",
      "Iteration 1650: error is 3.117992 (50 iterations in 9.01 seconds)\n",
      "Iteration 1700: error is 3.108941 (50 iterations in 9.17 seconds)\n",
      "Iteration 1750: error is 3.100308 (50 iterations in 9.02 seconds)\n",
      "Iteration 1800: error is 3.092346 (50 iterations in 9.21 seconds)\n",
      "Iteration 1850: error is 3.084940 (50 iterations in 9.18 seconds)\n",
      "Iteration 1900: error is 3.078180 (50 iterations in 9.21 seconds)\n",
      "Iteration 1950: error is 3.071527 (50 iterations in 9.30 seconds)\n",
      "Iteration 1999: error is 3.065283 (50 iterations in 9.06 seconds)\n",
      "Fitting performed in 394.96 seconds.\n",
      "Wrote the 10000 x 2 data matrix successfully!\n",
      "\n",
      "T-sne required 430.764343 seconds (7.179406 minutes) to run\n",
      "TSNE return code: 0\n",
      "CPU times: user 1.56 s, sys: 350 ms, total: 1.91 s\n",
      "Wall time: 7min 12s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "t_sne_result_gpu = tsne_bhcuda.t_sne(samples=features, use_scikit=False, files_dir=files_dir,\n",
    "                        no_dims=2, perplexity=perplexity, eta=learning_rate, theta=theta,\n",
    "                        iterations=iterations, gpu_mem=gpu_mem, randseed=77, verbose=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_tsne(t_sne_result_gpu, labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "!rm -rf train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conclusion\n",
    "\n",
    "Looking at the first plot from sklearn, we can see that the features are clustered into two groups, representing the dog and cat images. The second plot from CUDA, also shows two differentiated clusters, but in a different position copared to the first one. This might be due to differences in the optimization process and also because t-SNE models the datapoints as pairwise distances rather than absolute positions. Furthermore, since the algorithm isn’t deterministic, the problem might have multiple minima. As it can be expected, the C++ implementation is faster than the python one, but not by a high margin.\n",
    "\n",
    "As a conclusion, t-SNE maps from a high-dimensional space to 2 or 3 low-dimensional space by modeling disimilar datapoints by large pairwise distances, and modeling similar datapoints by small pairwise distances. Furthermore, it's cost function is easier to optimize in comparison with other methods.\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
